TM2C: A software transactional memory for many-cores

Transactional memory is an appealing paradigm for concurrent programming. Many software implementations of the paradigm were proposed in the last decades for both shared memory multi-core systems and clusters of distributed machines. However, chip manufacturers have started producing many-core architectures, with low network-on-chip communication latency and limited support for cache-coherence, rendering existing transactional memory implementations inapplicable. This paper presents TM2C, the first software Transactional Memory protocol for Many-Core systems. TM2C exploits network-on-chip communications to get granted accesses to shared data through efficient message passing. In particular, it allows visible read accesses and hence effective distributed contention management with eager conflict detection. We also propose FairCM, a companion contention manager that ensures starvation-freedom, which we believe is an important property in many-core systems, as well as an implementation of elastic transactions in these settings. Our evaluation on four benchmarks, i.e., a linked list and a hash table data structures as well as a bank and a MapReduce-like applications, indicates better scalability than locks and up to 20-fold speedup (relative to bare sequential code) when running 24 application cores. © 2012 ACM

Distributed Slicing in Dynamic Systems

Peer to peer (P2P) systems are moving from application specific architectures to a generic service oriented design philosophy. This raises interesting problems in connection with providing useful P2P middleware services capable of dealing with resource assignment and management in a large-scale, heterogeneous and unreliable environment. The slicing service, has been proposed to allow for an automatic partitioning of P2P networks into groups (slices) that represent a controllable amount of some resource and that are also relatively homogeneous with respect to that resource. In this paper we propose two gossip-based algorithms to solve the distributed slicing problem. The first algorithm speeds up an existing algorithm sorting a set of uniform random numbers. The second algorithm statistically approximates the rank of nodes in the ordering. The scalability, efficiency and resilience to dynamics of both algorithms rely on their gossip-based models. These algorithms are proved viable theoretically and experimentally

Dynamic Consensus: Increasing Blockchain Adaptability to Enterprise Applications

Decentralization powered by blockchain is validated for its capability to build trust like no other computational system before. The evolution of blockchain models has opened new use-cases that are becoming operational in many industry fields such as: energy, healthcare, banking, cross-border trade, aerospace, supply chain, and others. The core component of a decentralized architecture is the consensus algorithm - the set of rules that ensures an automated and fair agreement between the actors in the same network. Classic consensus algorithms are tailored to solve specific problems, but in an open ecosystem, each business case is unique and needs a certain level of customization. This paper introduces a new meta-consensus model called Dynamic Consensus, an architecture extension that allows multiple, complementary, consensus algorithms to run on the same platform. While classic consensus mechanisms are more appropriate for public or private systems (narrow set of rules), a dynamic approach would fit better for federated business consortiums (more rules and higher need for adaptability). The model is illustrated and analyzed as an ongoing experimental feature that can be added to enterprise blockchains designed to operate in cross-domain environments

On the Efficiency of Atomic Multi-reader, Multi-writer Distributed Memory

This paper considers quorum-replicated, multi-writer, multi-reader (MWMR) implementations of surviv-able atomic registers in a distributed message-passing system with processors prone to failures. Previous implementations in such settings invariably required two rounds of communication between readers/writers and replica owners. Hence the question arises whether it is possible to have single round read and/or write operations in this setting. As a first step, we present an algorithm, called CWFR, that allows the classic two round write operations, while supporting single round read operations. Since multiple write operations may be concurrent with a read operation, this algorithm involves an iterative (local) discovery of the latest completed write operation. This algorithm precipitates the question of whether fast (single round) writes may co-exist with fast reads. We thus devise a second algorithm, called SFW, that exploits a new technique called server side ordering (SSO), which –unlike previous approaches – places partial responsibility for the ordering of write operations on the replica owners (the servers). With SSO, fast write operations are introduced for the very first time in the MWMR setting. While this is possible, we show that under certain conditions the MWMR model imposes in-herent limitations on any quorum-based fast write implementation of a safe read/write register and potentiall

Local resource consumption shaping : a case for MapReduce

Today, resource capacity is no longer an issue for running large-scale distributed systems, such as MapReduce. As a result, it is often the case that resources are provisioned, for such systems, at the level of peak loads. This overprovisioning has become a serious efficiency issue in cloud data centers with poor resource utilization. The improvement of resource utilization can be achieved by concurrently running tasks sharing a common set of resources. However, many distributed systems spawn a large number of tasks that exhibit similar resource consumption patterns causing much performance interference/degradation that is primarily due to fair resource sharing. In this study, we consider the problem of "local resource consumption shaping" - an alternative to fair resource sharing - at the local node/core level.26 page(s

Optimistic concurrency with OPTIK

We introduce OPTIK, a new practical design pattern for designing and implementing fast and scalable concurrent data structures. OPTIK relies on the commonly-used technique of version numbers for detecting conflicting concurrent operations. We show how to implement the OPTIK pattern using the novel concept of OPTIK locks. These locks enable the use of version numbers for implementing very efficient optimistic concurrent data structures. Existing state-of-the-art lock-based data structures acquire the lock and then check for conflicts. In contrast, with OPTIK locks, we merge the lock acquisition with the detection of conflicting concurrency in a single atomic step, similarly to lock-free algorithms. We illustrate the power of our OPTIK pattern and its implementation by introducing four new algorithms and by optimizing four state-of-the-art algorithms for linked lists, skip lists, hash tables, and queues. Our results show that concurrent data structures built using OPTIK are more scalable than the state of the art